package com.sdy.util;

import com.sdy.po.OverView;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * OverView的工具类对象
 * 此类可对OverView类集合整理
 * 提取OverView类中各项信息，生成集合的方法
 * 提供根据传入的数据生成合适的 表高，步长 的方法
 * 和对日期进行格式化的方法
 */
@Component
public class OverViewUtil {

    /**
     * 核心方法！！！！！！！！！！！！！
     * 此方法将OverView类集和，按照属性分装成四个子集合
     * 并按照集合中的数据，生成前端需要的，列表高度，步长，等数据
     * 并放入Map中返回，方便前端调用
     * @param overViewList  传入的OverView类集合
     * @return
     */
    //数据结构:overViewMap--overViewDataList[]--propertyMap--List[]
    //                   -updateTimes[]                   -Result[]
    public Map<String, Object> getOverViewsInformation(List<OverView> overViewList){
        List<Map> overViewDataList = new ArrayList<>();
        Map<String,Object> overViewMap = new HashMap<>();
        Field[] fields = OverView.class.getDeclaredFields();
        System.out.println(fields.length);
        for (Field fild:fields) {
            String fieldName = fild.toString();
            if (!fieldName.substring(46).equals("id") && fieldName.indexOf("updateTime")<0){
                Map<String,Object> propertyMap = new HashMap<>();
                fieldName = fieldName.substring(45);
                List<Double> propertiesList = getPropertyList(overViewList,fieldName);
                Double[] result = getMaxAndStepSize(propertiesList);
                propertyMap.put("List",propertiesList);
                propertyMap.put("Result",result);
                overViewDataList.add(propertyMap);
            }
        }
        overViewMap.put("overViewDataList",overViewDataList);
        overViewMap.put("updateTimes",getUpdateTimeList(overViewList));
        return overViewMap;
    }

    /**
     * 此方提取集合中的updatetime属性
     * 返回一个字符串类型集合
     * @param overViewList
     * @return
     */
    public List<String> getUpdateTimeList(List<OverView> overViewList){
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        List<String> updateTimeList = new ArrayList<>();
        for (OverView overView:overViewList) {
            if (overView!=null){
                updateTimeList.add(simpleDateFormat.format(overView.getUpdateTime()));
            }
        }
        System.out.println(updateTimeList.toString());
        return updateTimeList;
    }

    /**
     * 此方提取OverView集合中的指定属性
     * 返回一个整数类型集合
     * @param overViewList
     * @return
     */
    public List<Double> getPropertyList(List<OverView> overViewList, String name){
        List<Double> propertyList = new ArrayList<>();
        Method method;
        char[] cs=name.toCharArray();
        //首字母转大写
        cs[0]-=32;
        name = "get"+String.valueOf(cs);
        System.out.println("1111111111"+name);

        for (OverView overView:overViewList) {
            if (overView != null){
                try {
                    method = overView.getClass().getMethod(name,null);
                    propertyList.add((Double) method.invoke(overView,null));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(propertyList.toString());
        return propertyList;
    }

    /**
     * 此方法根据传入的集合选出最高数据
     * 并根据此数据寻找合适的表步长
     * [0]是max,[1]是stepSize
     * @param propertyList
     * @return
     */
    public Double[] getMaxAndStepSize(List<Double> propertyList){
        Double[] result = new Double[2];
        Double max = 0.0;
        for (Double data:propertyList) {
            if (data!=null && data>max){
                max = data;
            }
        }
        Double num = Math.pow(10,Integer.toString(max.intValue()+1).length()-1);
        Integer order = num.intValue();
        max /=order;
        if (max<=3){
            result[1] = Double.valueOf(order/2);
        }
        else if (max<=6){
            result[1] = Double.valueOf(order);
        }
        else {
            result[1] = Double.valueOf(order*2);
        }
        result[0] = Double.valueOf((max.intValue()+1)*order);

        return result;
    }
}
